package edu.upn.sigemfi.plt.beans;

import edu.upn.sigemfi.plt.bc.CuentaDelegate;
import edu.upn.sigemfi.plt.bc.TipoCuentaDelegate;
import edu.upn.sigemfi.plt.bc.TarjetaDebitoDelegate;
import edu.upn.sigemfi.plt.bc.SucursalDelegate;
import edu.upn.sigemfi.plt.bc.DetalleCuentaClienteDelegate;
import edu.upn.sigemfi.plt.bc.MonedaDelegate;
import edu.upn.sigemfi.plt.bc.TipoCambioDelegate;
import edu.upn.sigemfi.plt.be.Cuenta;
import edu.upn.sigemfi.plt.be.EstadoCuenta;
import edu.upn.sigemfi.plt.be.TipoCuenta;
import edu.upn.sigemfi.plt.be.TarjetaDebito;
import edu.upn.sigemfi.seg.be.PersonaNatural;
import edu.upn.sigemfi.seg.be.Persona;
import edu.upn.sigemfi.plt.be.DetalleCuentaClientePK;
import edu.upn.sigemfi.plt.be.DetalleCuentaCliente;
import edu.upn.sigemfi.plt.be.EstadoDetalleCuenta;
import edu.upn.sigemfi.plt.be.ModalidadAfiliacion;
import edu.upn.sigemfi.seg.be.PersonaJuridica;
import edu.upn.sigemfi.seg.be.Sucursal;
import edu.upn.sigemfi.ope.be.Moneda;
import edu.upn.sigemfi.ope.be.TipoCambio;
import edu.upn.sigemfi.plt.be.EstadoTarjetaDebito;
import edu.upn.sigemfi.plt.be.TipoTipoCuenta;
import java.util.List;
import javax.faces.model.SelectItem;
import java.util.ArrayList;
import java.util.Date;
import edu.upn.sigemfi.seg.beans.AbstractController;

/**
 *
 * @author Gerard
 */
public class CuentaController extends AbstractController {

    private CuentaDelegate cuentaDelegado;
    private DetalleCuentaClientePK detalleCuentaClientePK;
    private DetalleCuentaCliente detalleCuentaCliente;
    private TipoCuentaDelegate tipoCuentaCuentaDelegado;
    private TarjetaDebitoDelegate tarjetaDebitoDelegado;
    private SucursalDelegate sucursalDelegado;
    private DetalleCuentaClienteDelegate detalleCuentaClienteDelegate;
    private MonedaDelegate monedaDelegate;
    private TipoCambioDelegate tipoCambioDelegate;
    public Cuenta cuenta;
    private Cuenta cuentaCliente;//Utilizada para el UC Asociacion con CLiente
    private ModalidadAfiliacion modalidadAfiliacion;
    private TipoCuenta tipoCuenta;
    private TipoTipoCuenta tipoTipoCuenta;
    private List<Moneda> monedas;
    private List<TipoCambio> tiposCambio;
    private List<TipoCuenta> listaTiposCuentas;
    private List<TarjetaDebito> listaTarjetaDebitos;
    private List<Sucursal> listaSucursales;
    //estas listas tambien se usaran para actualizar los mancomunados de las cuentas ----------------------------
    private List<PersonaNatural> personasNaturalesAgregar;//para recibir a las personas que vienen desde otra JSP
    private List<PersonaJuridica> personasJuridicasAgregar;//para recibir a las personas que vienen desde otra JSP
    //------------------------------------------------------------------------------------------------------------
    private boolean bolAgregarTarjeta;
    private boolean bolRegistrarPlazoFijo;
    private boolean bolAsociacionCliente;
    private boolean bolInicioTablaAgregarPersonas;
    //para UC:Exonerar ITF
    private boolean bolBusquedaCuentaNombre;
    private boolean bolBusquedaCuentaNroCuenta;
    private boolean bolBusquedaCuentaTipoCuenta;
    //private boolean bolexonerar;
    private String opcionFiltro;
    private String exonerarNroCuenta;
    private String exonerarDni;
    private String exonerarRuc;
    private TipoCuenta exonerarTipoCuenta;
    private Cuenta cuentaAExonerar;
    private List<Cuenta> cuentasAExonerar;
    private TipoCuenta tipoCuentaAExonerar;
    private TarjetaDebito tarjetaAAgregar;
    //-----variables para prueba de consultas
    private List<Cuenta> listaCuentasPrueba;
    private List<PersonaNatural> listaPersonasNaturalesPrueba;
    private AsosiacionCuentaClienteController asoCueCont;//Solo para manejar algunas opciones del COntroller AsociarCuentaCliente
    //private String modalidad;

    public CuentaController() {
        cuentaDelegado = new CuentaDelegate();
        tipoCuentaCuentaDelegado = new TipoCuentaDelegate();
        tarjetaDebitoDelegado = new TarjetaDebitoDelegate();
        sucursalDelegado = new SucursalDelegate();
        detalleCuentaClienteDelegate = new DetalleCuentaClienteDelegate();
//        monedaDelegate = new MonedaDelegate();
//        tipoCambioDelegate = new TipoCambioDelegate();
        bolRegistrarPlazoFijo = false;
        bolAgregarTarjeta = false;
        bolInicioTablaAgregarPersonas = false;
        bolAsociacionCliente = false;//sirve para controlar si agregamos a los titulares a la cuenta desde el
        //Nueva Cuenta

        try {
            listaTiposCuentas = tipoCuentaCuentaDelegado.listar();
            listaTarjetaDebitos = tarjetaDebitoDelegado.listar();
            listaSucursales = sucursalDelegado.listar();
            //para prueba de consultas - luego borrar
            //listaCuentasPrueba = cuentaDelegado.buscarCuentasPorDni("44935432");
            listaCuentasPrueba = cuentaDelegado.buscarCuentaPorMontoActual("<=", 500.00);
            listaPersonasNaturalesPrueba = cuentaDelegado.buscarPersonasNaturalesPorNroCuenta("100000006");
        //modalidad = cuentaDelegado.buscarModalidadAfiliacionPorNumeroCuenta(11);
        } catch (Exception e) {
        }
        //para guardar el array dentro de DetalleCuentaCliente
        personasNaturalesAgregar = new ArrayList<PersonaNatural>();
        personasJuridicasAgregar = new ArrayList<PersonaJuridica>();
        detalleCuentaClientePK = new DetalleCuentaClientePK();
        detalleCuentaCliente = new DetalleCuentaCliente();


    }

    //---------------------------GENERAL
    public String mostrar() {
        //para poder activar las opciones de actualizar mancmunados
        bolInicioTablaAgregarPersonas = true;
        personasJuridicasAgregar = null;
        personasNaturalesAgregar = null;

        //metodo para verificar que tipo de cliente nos devuelve la cuenta seleccionada
        try {
            personasNaturalesAgregar = cuentaDelegado.buscarPersonasNaturalesPorNroCuenta(cuenta.getNroCuenta());
        } catch (Exception e) {
            //personasNaturalesAgregar = null;
        }
        try {
            personasJuridicasAgregar = cuentaDelegado.buscarPersonasJuridicasPorNroCuenta(cuenta.getNroCuenta());
            personasNaturalesAgregar = null;//para eliminar la opcion de mostrar la lista de personas naturales vacia

        } catch (Exception e) {
            personasJuridicasAgregar = null;
        }
        return "mostrar";
    }

    public String cancelar() {
        reiniciarEstados();
        return "listar";
    }

    public String index() {
        return "index";
    }

    public String cuenta() {
        return "cuenta";
    }

    public String listar() {
        return "listar";
    }

    public String editar() {
        //para poder activar las opciones de actualizar mancmunados
        bolInicioTablaAgregarPersonas = true;
        //metodo para verificar que tipo de cliente nos devuelve la cuenta seleccionada
        try {
            personasNaturalesAgregar = cuentaDelegado.buscarPersonasNaturalesPorNroCuenta(cuenta.getNroCuenta());
        } catch (Exception e) {
            personasNaturalesAgregar = null;
        }
        try {
            personasJuridicasAgregar = cuentaDelegado.buscarPersonasJuridicasPorNroCuenta(cuenta.getNroCuenta());
            bolInicioTablaAgregarPersonas = false;//para no permitir editar el CLiente juridico de la cuenta asociada

        } catch (Exception e) {
            personasJuridicasAgregar = null;
        }

        return "editar";
    }
    //---------------------------CUENTAS

    public String nuevo() {
        bolAgregarTarjeta = true;
        cuenta = new Cuenta();
        tipoCuenta = new TipoCuenta();
        return "nuevo";
    }

    public String registrar() {
//        String prueba = "";
        try {
            //Verificamos el modo de Afliacion
            if (personasNaturalesAgregar.size() > 1 && modalidadAfiliacion.toString() == "Individual") {
                error("Por favor Seleccionar una de las Modalidades Mancomunadas");
                return null;
            } else if ((personasNaturalesAgregar.size() == 1 && modalidadAfiliacion.toString() == "MancomunadoIndistinta") || (personasNaturalesAgregar.size() == 1 && modalidadAfiliacion.toString() == "MancomunadoConjunta")) {
                error("Por favor Seleccionar Modalidad Individual");
                return null;
            }

            //si tiene mancomunados asociados
            if ((personasNaturalesAgregar.size() > 1) || (personasJuridicasAgregar.size() > 1)) {
                cuenta.setEstadoCuenta(EstadoCuenta.TitularAsociado);
            }

            //vemos si tiene una tarjeta agregada
            if (tarjetaAAgregar == null) {
                cuenta.setEstadoCuenta(EstadoCuenta.Creado);//por defecto los creados tendran este estado
            } else {
                if (tarjetaAAgregar.getEstado() == EstadoTarjetaDebito.NoAsignado) {
                    tarjetaAAgregar.setEstado(EstadoTarjetaDebito.Asignado);
                    tarjetaDebitoDelegado.editar(tarjetaAAgregar);
                //En caso se asocie por primera vez
                }
                cuenta.setEstadoCuenta(EstadoCuenta.TarjetaAsociada);//por defecto los creados tendran este estado
            }

            //creamos la cuenta
            //cuenta.setFechaApertura(new java.sql.Date(getFechaActual().getYear(), getFechaActual().getMonth(), getFechaActual().getDay()));
            cuenta.setFechaApertura(new Date());
            cuenta.setTasaItf(00.07);//tasa referencial
            cuentaDelegado.crear(cuenta);

            //cuando agregamos titulares desde nuevo
            if (personasNaturalesAgregar != null) {
                for (PersonaNatural pn : personasNaturalesAgregar) {
                    detalleCuentaClientePK = new DetalleCuentaClientePK();
                    detalleCuentaClientePK.setFidSegPersona(pn.getIdPersona());
                    detalleCuentaClientePK.setFidPltCuenta(cuenta.getIdCuenta());
                    detalleCuentaCliente.setDetalleCuentaClientePK(detalleCuentaClientePK);
                    detalleCuentaCliente.setModalidadAfiliacion(modalidadAfiliacion);
                    detalleCuentaCliente.setEstadoDetalleCuentaCliente(EstadoDetalleCuenta.Asociado);
                    detalleCuentaCliente.setFechaAfiliacion(new java.sql.Date(getFechaActual().getYear(), getFechaActual().getMonth(), getFechaActual().getDay() + 1));
                    detalleCuentaClienteDelegate.crear(detalleCuentaCliente);
                }
            //cambiamos el estado a Disponibles
            }
            if (personasJuridicasAgregar != null) {
                for (PersonaJuridica pj : personasJuridicasAgregar) {
                    detalleCuentaClientePK = new DetalleCuentaClientePK();
                    detalleCuentaClientePK.setFidSegPersona(pj.getIdPersona());
                    detalleCuentaClientePK.setFidPltCuenta(cuenta.getIdCuenta());
                    detalleCuentaCliente.setDetalleCuentaClientePK(detalleCuentaClientePK);
                    detalleCuentaCliente.setModalidadAfiliacion(ModalidadAfiliacion.Individual);//nunca habran mancomunada con personas juridicas
                    detalleCuentaCliente.setEstadoDetalleCuentaCliente(EstadoDetalleCuenta.Asociado);
                    //detalleCuentaCliente.setFechaAfiliacion(new java.sql.Date(getFechaActual().getYear(), getFechaActual().getMonth(), getFechaActual().getDay() + 1));
                    detalleCuentaCliente.setFechaAfiliacion(new Date());
                    detalleCuentaClienteDelegate.crear(detalleCuentaCliente);
                }
            //cambiamos el estado a Disponibles
            } else {
                //no hacemos nada
            }

            if ((tarjetaAAgregar != null && personasNaturalesAgregar != null) || (tarjetaAAgregar != null && personasJuridicasAgregar != null)) {
                //Solo en el caso tengan tarjeta y esten asociados
                //cambiamos el estado a Disponibles
                cuenta.setEstadoCuenta(EstadoCuenta.Aperturado);
                cuentaDelegado.editar(cuenta);
            }

            personasJuridicasAgregar = new ArrayList<PersonaJuridica>();
            personasNaturalesAgregar = new ArrayList<PersonaNatural>();
            cuenta = new Cuenta();//vaciamos la cuenta
            tarjetaAAgregar = new TarjetaDebito();//vaciamos la tarjeta que estaba agregandose
            bolAsociacionCliente = false;
            // bolAgregarTarjeta = true;
            reiniciarEstados();
            asoCueCont.reiniciarEstados();
            info("La Cuenta se Creó Correctamente");
        } catch (Exception e) {
            error(e.getMessage());
        }
        return "listar";
    }

    public String actualizar() {
        try {
            cuenta.setEstadoCuenta(EstadoCuenta.TarjetaAsociada);
            cuentaDelegado.editar(cuenta);
        } catch (Exception e) {
            error(e.getMessage());
        }
        asoCueCont.setNuevosMancomunadosAgregar(new ArrayList<PersonaNatural>());//limpiamos los nuevos mancomunados que estamos trabajando
        return "listar";
    }

    public String eliminar() {
        try {
            cuentaDelegado.eliminar(cuenta);
            info("La Cuenta se Eliminó Correctamente");
        } catch (Exception e) {
            error(e.getMessage());
        }
        return "volver";
    }

    public Cuenta buscar(Long codigo) {
        try {
            cuentaDelegado.buscar(codigo);
            info("La Cuenta deseada se Encontró");
        } catch (Exception e) {
            error(e.getMessage());
        }
        return null;
    }
// -> asociarCuentaPersona

    public String asociarTitulares() {
        AsosiacionCuentaClienteController tempcontroller = (AsosiacionCuentaClienteController) getBean("AsocCuenClienController");
        if (tempcontroller == null) {
            //no hago nada
        } else {
            //para evitar opciones de "agregarCLiente" en el Cliente/listar.jsp
            tempcontroller.bolAgregarPersonaNatural = true;//para controlar la opcion de agregar persona JURIDICA
            tempcontroller.bolAgregarPersonaJuridica = true;//para controlar la opcion de agregar persona NATURAL
        }
        //utilizaremos el objeto Cuenta para agregar a los titulares
        bolAsociacionCliente = true;//para activar el agregar en
        bolInicioTablaAgregarPersonas = true;
        return "asociarClienteDesdeNuevo";
    }

    public String editarTitulares() {
        //utilizaremos el objeto Cuenta para agregar a los titulares
        bolAsociacionCliente = true;//para activar el agregar en
        bolInicioTablaAgregarPersonas = true;
        return "asociarClienteDesdeNuevo";
    }

    public String asociarTarjeta() {//para agregar tarjeta a una cuenta que no fue asociada aun.
        tarjetaAAgregar = new TarjetaDebito();
        bolAgregarTarjeta = false;
//        } else {
//            bolAgregarTarjeta = true;//se utilizara paara que quede activado la opcion de agregar en el listar tarjeta
//        }
        return "agregarTarjeta";
    }

    public String agregarTarjeta2() {
        cuenta.setFidPltTarjetaDebito(tarjetaAAgregar);//agrego la tarjeta seleccionada
        return "agregarTarjeta2";
    }

    public String agregarTarjeta() {
        tarjetaAAgregar = new TarjetaDebito();
        if (bolAgregarTarjeta == false) {//para la opcion "Cambiar Tarjeta"
            bolAgregarTarjeta = true;
        }
//        } else {
//            bolAgregarTarjeta = true;//se utilizara paara que quede activado la opcion de agregar en el listar tarjeta
//        }
        return "agregarTarjeta";
    }

    // DE tarjetadebito/listar.jsp A cuenta/nuevo.jsp
    public String agregarTarjeta1() {

        //if (cuenta.getIdCuenta() == null) {//quiere decir que no se ha guardado aun
        cuenta.setFidPltTarjetaDebito(tarjetaAAgregar);//le agregamos la tarjeta seleccionada
        cuenta.setEstadoCuenta(EstadoCuenta.TarjetaAsociada);
        bolAgregarTarjeta = false;
        //tarjetaAAgregar = null;//limpiamos la tarjeta que estaba
        return "agregarTarjeta1";
    //} else {//estamos editando una cuenta guardada
    //return "";
    }


    //--------------------------------------------TIPO DE CUENTAS
    public SelectItem[] getTipoCuentas() {
        SelectItem[] selects;
        try {
            if(tipoTipoCuenta == null){
            listaTiposCuentas = tipoCuentaCuentaDelegado.listar();
            }
            listaTiposCuentas = cuentaDelegado.buscarTipoCuentaPorTipoTipoCuenta(tipoTipoCuenta);
            selects = new SelectItem[listaTiposCuentas.size()];
            int i = 0;
            for (TipoCuenta tp : listaTiposCuentas) {
                selects[i++] = new SelectItem(tp, tp.getNombre());
            }
        } catch (Exception e) {
            selects = new SelectItem[1];
            selects[0] = new SelectItem(null, "Error al momento de consultar Tipos de Cuenta");
            System.out.println(e.getMessage());
            error(e.getMessage());
        }
        return selects;
    }

    public SelectItem[] getTipoTipoCuentas() {

        TipoTipoCuenta[] tipoTipoCuentas = TipoTipoCuenta.values();

        SelectItem[] select = new SelectItem[tipoTipoCuentas.length];
        int i = 0;
        for (TipoTipoCuenta ttp : tipoTipoCuentas) {
            select[i++] = new SelectItem(ttp, ttp.toString());
        }
        return select;
    }

    public SelectItem[] getEstadosCuenta() {
        EstadoCuenta[] estadosCuenta = EstadoCuenta.values();

        SelectItem[] select = new SelectItem[estadosCuenta.length];
        int i = 0;
        for (EstadoCuenta ec : estadosCuenta) {
            select[i++] = new SelectItem(ec, ec.toString());
        }
        return select;
    }

    //--------------------------------------------TARJETA DEBITO
    public SelectItem[] getTarjetasDebito() {
        SelectItem[] selects = null;
        try {
            selects = new SelectItem[listaTarjetaDebitos.size()];
            int i = 0;
            for (TarjetaDebito td : listaTarjetaDebitos) {
                selects[i++] = new SelectItem(td, td.getNroTarjeta());
            }
        } catch (Exception e) {
            selects = new SelectItem[1];
            selects[0] = new SelectItem(null, "Error al momento de consultar Tarjeta Debito");
            System.out.println(e.getMessage());
            error(e.getMessage());
        }
        return selects;
    }
    //--------------------------------------------SUCURSAL

    public SelectItem[] getSucursales() {
        SelectItem[] selects = null;
        try {
            listaSucursales  = sucursalDelegado.listar();
            selects = new SelectItem[listaSucursales.size()];
            int i = 0;
            for (Sucursal s : listaSucursales) {
                selects[i++] = new SelectItem(s, s.getNombre());
            }
        } catch (Exception e) {
            selects = new SelectItem[1];
            selects[0] = new SelectItem(null, "Error al momento de consultar Sucursales");
            System.out.println(e.getMessage());
            error(e.getMessage());
        }
        return selects;
    }
    //--------------------------------------------MONEDAS

    public SelectItem[] getMonedas() {
        SelectItem[] selects = null;
        try {
            monedas = monedaDelegate.listar();
            selects = new SelectItem[monedas.size()];
            int i = 0;
            for (Moneda s : monedas) {
                selects[i++] = new SelectItem(s, s.getSimbolo());
            }
        } catch (Exception e) {
            selects = new SelectItem[1];
            selects[0] = new SelectItem(null, "Error al momento de consultar Monedas");
            System.out.println(e.getMessage());
            error(e.getMessage());
        }
        return selects;
    }
    //-------------------------------------------- EL TIPO DE CAMBIO SE GUARDA DEPENDIENDO DE LA FECHA

    public String getmodalidad() {
        String modalidad = "";
        try {
            //nos pueda dar la modalidad de la cuenta con la que estamos manejando
            modalidad = cuentaDelegado.buscarModalidadAfiliacionPorNumeroCuenta(cuenta.getIdCuenta());
        } catch (Exception e) {
            error("No se pudo cargar el Modo de Afiliacion de la Cuenta");
        }
        return modalidad;
    }

//GETs and SETTERs
    public List<Cuenta> getCuentas() {
        try {
            return cuentaDelegado.listar();
        } catch (Exception e) {
            error(e.getMessage());
        }
        return null;
    }

    public String reiniciarEstados() {
        tarjetaAAgregar = new TarjetaDebito();
        personasJuridicasAgregar = null;
        personasNaturalesAgregar = null;
        bolRegistrarPlazoFijo = false;
        bolAgregarTarjeta = false;
        bolAsociacionCliente = false;
        bolInicioTablaAgregarPersonas = false;
        bolBusquedaCuentaNombre = false;
        bolBusquedaCuentaNroCuenta = false;
        bolBusquedaCuentaTipoCuenta = false;
        
        cuenta = new Cuenta();
        //UC:Exonerar
        cuentasAExonerar = new ArrayList<Cuenta>();//para que se limpie en cada busquedaz
        exonerarDni = "";
        tipoCuentaAExonerar = new TipoCuenta();
        exonerarNroCuenta = "";
        return "";
    }

    public SelectItem[] getModalidadesAfiliacion() {
        ModalidadAfiliacion[] modalidadesAfilicacion = ModalidadAfiliacion.values();
        SelectItem[] select = new SelectItem[modalidadesAfilicacion.length];
        int i = 0;
        for (ModalidadAfiliacion ma : modalidadesAfilicacion) {
            select[i++] = new SelectItem(ma, ma.toString());//se completa el cuadro normalmente
        }
        return select;
    }

    //----------------------------------------CU:EXONERAR ITF
//cuenta/listar.jsp -> cuenta/exonerarCuenta
    public String exonerarCuenta() {
        cuentasAExonerar = new ArrayList<Cuenta>();
        cuentaAExonerar = new Cuenta();
        tipoCuentaAExonerar = new TipoCuenta();
        reiniciarEstados();
//        try {
//            if (bolBusquedaCuentaNombre == true) {
//                cuentasAExonerar = cuentaDelegado.buscarCuentasPorDni(exonerarDni);
//            } else if (bolBusquedaCuentaTipoCuenta == true) {
//                cuentasAExonerar = cuentaDelegado.buscarCuentasPorTipoCuenta(tipoCuenta);
//            } else if (bolBusquedaCuentaNroCuenta == true) {
//                cuentaAExonerar = cuentaDelegado.buscarCuentaPorNroCuenta(exonerarNroCuenta);
//            }
//        } catch (Exception e) {
//            error("Error al buscar cuenta");
//        }
        return "exonerarCuenta";
    }
//cuenta/exonerarCuenta -> cuenta/listar.jsp

    public String cuentaExonerada() {
        //ejecucion de la exoneracion
        try {
            for (Cuenta c : cuentasAExonerar) {
                cuentaDelegado.editar(c);
            }
            info("Cuentas exoneradas Correctamente");
        } catch (Exception e) {
            error("Error al exonerar las cuentas seleccionadas");
        }
        return "cuentaExonerada";
    }

    public String buscarCuentas() {
        cuentasAExonerar = new ArrayList<Cuenta>();//para que se limpie en cada busquedaz
        //bolexonerar = true;
        try {
            String opcion = opcionFiltro.toString();
            if (opcion.equals("nt")) {
                cuentasAExonerar = cuentaDelegado.buscarCuentasPorDni(exonerarDni);
            } else if (opcion.equals("tc")) {
                cuentasAExonerar = cuentaDelegado.buscarCuentasPorTipoCuenta(tipoCuentaAExonerar);
            } else if (opcion.equals("nc")) {
                cuentaAExonerar = cuentaDelegado.buscarCuentaPorNroCuenta(exonerarNroCuenta);
                cuentasAExonerar.add(cuentaAExonerar);
            }else if (opcion.equals("nr")) {
                cuentasAExonerar = cuentaDelegado.buscarCuentasPorRuc(exonerarRuc);
            }

        } catch (Exception e) {
            error("Error al buscar cuenta segun la opcion : ' " + opcionFiltro + " '");
        }
        return "";
    }

    public String limpiar() {
        cuentasAExonerar = new ArrayList<Cuenta>();//para que se limpie en cada busquedaz
        exonerarDni = "";
        tipoCuentaAExonerar = new TipoCuenta();
        exonerarNroCuenta = "";
        return null;
    }

    public String activarExoneracion() {
        cuenta.setTasaItf(00.00);
        //bolexonerar = false;//para que se muestre la opcion de Desactivar Exoneracion
        return null;
    }

    public String desactivarExoneracion() {
        cuenta.setTasaItf(00.07);//valor referencial del ITF
        //bolexonerar = true;//para que se muestre la opcion de Activar Exoneracion
        return null;
    }

//----------------------------------------
    public Cuenta getCuenta() {
        return cuenta;
    }

    public void setCuenta(Cuenta cuenta) {
        this.cuenta = cuenta;
    }

    public TipoCuenta getTipoCuenta() {
        return tipoCuenta;
    }

    public void setTipoCuenta(TipoCuenta tipoCuenta) {
        this.tipoCuenta = tipoCuenta;
    }

    public boolean isBolAgregarTarjeta() {
        return bolAgregarTarjeta;
    }

    public void setBolAgregarTarjeta(boolean bolAgregarTarjeta) {
        this.bolAgregarTarjeta = bolAgregarTarjeta;
    }

    public TarjetaDebito getTarjetaAAgregar() {
        return tarjetaAAgregar;
    }

    public void setTarjetaAAgregar(TarjetaDebito tarjetaAAgregar) {
        this.tarjetaAAgregar = tarjetaAAgregar;
    }

    public boolean isBolRegistrarPlazoFijo() {
        return bolRegistrarPlazoFijo;
    }

    public void setBolRegistrarPlazoFijo(boolean bolRegistrarPlazoFijo) {
        this.bolRegistrarPlazoFijo = bolRegistrarPlazoFijo;
    }

    public Cuenta getCuentaCliente() {
        return cuentaCliente;
    }

    public void setCuentaCliente(Cuenta cuentaCliente) {
        this.cuentaCliente = cuentaCliente;
    }

    public boolean isBolAsociacionCliente() {
        return bolAsociacionCliente;
    }

    public void setBolAsociacionCliente(boolean bolAsociacionCliente) {
        this.bolAsociacionCliente = bolAsociacionCliente;
    }

    public DetalleCuentaCliente getDetalleCuentaCliente() {
        return detalleCuentaCliente;
    }

    public void setDetalleCuentaCliente(DetalleCuentaCliente detalleCuentaCliente) {
        this.detalleCuentaCliente = detalleCuentaCliente;
    }

    public List<PersonaNatural> getPersonasNaturalesAgregar() {
        return personasNaturalesAgregar;
    }

    public void setPersonasNaturalesAgregar(List<PersonaNatural> personasNaturalesAgregar) {
        this.personasNaturalesAgregar = personasNaturalesAgregar;
    }

    public List<PersonaJuridica> getPersonasJuridicasAgregar() {
        return personasJuridicasAgregar;
    }

    public void setPersonasJuridicasAgregar(List<PersonaJuridica> personasJuridicasAgregar) {
        this.personasJuridicasAgregar = personasJuridicasAgregar;
    }

//----------------------------------PRUEBAS DE CONSULTAS
    public List<Cuenta> getListaCuentasPrueba() {
        return listaCuentasPrueba;
    }

    public void setListaCuentasPrueba(List<Cuenta> listaCuentasPrueba) {
        this.listaCuentasPrueba = listaCuentasPrueba;
    }

    public List<PersonaNatural> getListaPersonasNaturalesPrueba() {
        return listaPersonasNaturalesPrueba;
    }

    public void setListaPersonasNaturalesPrueba(List<PersonaNatural> listaPersonasNaturalesPrueba) {
        this.listaPersonasNaturalesPrueba = listaPersonasNaturalesPrueba;
    }

    public boolean isBolInicioTablaAgregarPersonas() {
        return bolInicioTablaAgregarPersonas;
    }

    public void setBolInicioTablaAgregarPersonas(boolean bolInicioTablaAgregarPersonas) {
        this.bolInicioTablaAgregarPersonas = bolInicioTablaAgregarPersonas;
    }

    public AsosiacionCuentaClienteController getAsoCueCont() {
        return asoCueCont;
    }

    public void setAsoCueCont(AsosiacionCuentaClienteController asoCueCont) {
        this.asoCueCont = asoCueCont;
    }

    public ModalidadAfiliacion getModalidadAfiliacion() {
        return modalidadAfiliacion;
    }

    public String getNombreModalidadAfiliacion() {
        return modalidadAfiliacion.toString();
    }

    public void setModalidadAfiliacion(ModalidadAfiliacion modalidadAfiliacion) {
        this.modalidadAfiliacion = modalidadAfiliacion;
    }

//    public String getModalidad() {
//        return modalidad;
//    }
//
//    public void setModalidad(String modalidad) {
//        this.modalidad = modalidad;
//    }
    private Date getFechaActual() {
        return new Date();
    }

    public boolean isBolBusquedaCuentaNombre() {
        return bolBusquedaCuentaNombre;
    }

    public void setBolBusquedaCuentaNombre(boolean bolBusquedaCuentaNombre) {
        this.bolBusquedaCuentaNombre = bolBusquedaCuentaNombre;
    }

    public boolean isBolBusquedaCuentaNroCuenta() {
        return bolBusquedaCuentaNroCuenta;
    }

    public void setBolBusquedaCuentaNroCuenta(boolean bolBusquedaCuentaNroCuenta) {
        this.bolBusquedaCuentaNroCuenta = bolBusquedaCuentaNroCuenta;
    }

    public boolean isBolBusquedaCuentaTipoCuenta() {
        return bolBusquedaCuentaTipoCuenta;
    }

    public void setBolBusquedaCuentaTipoCuenta(boolean bolBusquedaCuentaTipoCuenta) {
        this.bolBusquedaCuentaTipoCuenta = bolBusquedaCuentaTipoCuenta;
    }

    public String getExonerarDni() {
        return exonerarDni;
    }

    public void setExonerarDni(String exonerarDni) {
        this.exonerarDni = exonerarDni;
    }

    public String getExonerarNroCuenta() {
        return exonerarNroCuenta;
    }

    public void setExonerarNroCuenta(String exonerarNroCuenta) {
        this.exonerarNroCuenta = exonerarNroCuenta;
    }

    public Cuenta getCuentaAExonerar() {
        return cuentaAExonerar;
    }

    public void setCuentaAExonerar(Cuenta cuentaAExonerar) {
        this.cuentaAExonerar = cuentaAExonerar;
    }

    public TipoCuenta getTipoCuentaAExonerar() {
        return tipoCuentaAExonerar;
    }

    public void setTipoCuentaAExonerar(TipoCuenta tipoCuentaAExonerar) {
        this.tipoCuentaAExonerar = tipoCuentaAExonerar;
    }

    public TipoCuenta getExonerarTipoCuenta() {
        return exonerarTipoCuenta;
    }

    public void setExonerarTipoCuenta(TipoCuenta exonerarTipoCuenta) {
        this.exonerarTipoCuenta = exonerarTipoCuenta;
    }

    public String getOpcionFiltro() {
        return opcionFiltro;
    }

    public void setOpcionFiltro(String opcionFiltro) {
        this.opcionFiltro = opcionFiltro;
    }

    public List<Cuenta> getCuentasAExonerar() {
        return cuentasAExonerar;
    }

    public void setCuentasAExonerar(List<Cuenta> cuentasAExonerar) {
        this.cuentasAExonerar = cuentasAExonerar;
    }

    public String getExonerarRuc() {
        return exonerarRuc;
    }

    public void setExonerarRuc(String exonerarRuc) {
        this.exonerarRuc = exonerarRuc;
    }

    public TipoTipoCuenta getTipoTipoCuenta() {
        return tipoTipoCuenta;
    }

    public void setTipoTipoCuenta(TipoTipoCuenta tipoTipoCuenta) {
        this.tipoTipoCuenta = tipoTipoCuenta;
    }
    
}
